#include "c43020.h"
#include "main.h"
#include <stdio.h>

//********************************************************************************
uint16_t firstRotate;
uint16_t secondRotate;
extern UART_HandleTypeDef huart1;


void changePinMode(uint16_t GPIO_Pin, uint32_t GPIO_Pin_Mode)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    switch (GPIO_Pin)
    {
    case BUT_LEFT_Pin:
        GPIO_InitStruct.Pin = BUT_LEFT_Pin;
        GPIO_InitStruct.Mode = GPIO_Pin_Mode;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(BUT_LEFT_GPIO_Port, &GPIO_InitStruct);
        break;
    case BUT_RIGHT_Pin:
        GPIO_InitStruct.Pin = BUT_RIGHT_Pin;
        GPIO_InitStruct.Mode = GPIO_Pin_Mode;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(BUT_RIGHT_GPIO_Port, &GPIO_InitStruct);
        break;

    default:
        break;
    }
}

//********************************************************************************
void _delay_ms(uint32_t t)
{
    HAL_Delay(t);
}

//********************************************************************************
void delay_s(uint32_t t)
{
    for (uint32_t i = 0; i < t; i++)
    {
        HAL_Delay(1000);
    }
}

//********************************************************************************
void clockDelay(void)
{
    /*uint32_t i;
    for (i = 0; i < 72000; i++)
    {
        i = i;
    }*/
    volatile uint32_t i = 0;
    volatile uint32_t time = 10;
    while (time--)
    {
        i = 16; //自己定义
        while (i--)
            ;
    }
}

//********************************************************************************
void Clock(void)
{
    /*
        ClrBit(PORTD,WR);
        //_delay_us(1);
        asm("nop");
        SetBit(PORTD,WR);
        //_delay_us(1);
        asm("nop");
    */
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    clockDelay();

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    clockDelay();
}

//********************************************************************************
void delay(void)
{
    clockDelay();
}

//********************************************************************************
void Led(uint8_t b)
{
    /*PORTC = (PORTC & 0b11100001) | (b & 0b00011110);
	DDRC  = 0b00111110;*/

    if(b != 0){
        HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
    }
    else 
    {
        HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
    }
}

void userLed(uint8_t status)
{
    if (status != 0)
    {
        HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
    }
    else
    {
        HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
    }
}

void userLedFlash(uint32_t cnt, uint32_t onTime, uint32_t offTime)
{
    for (uint32_t i = 0; i < cnt; i++)
    {
        userLed(1);
        HAL_Delay(onTime);

        userLed(0);
        HAL_Delay(offTime);
    }
}

void ledRT(uint8_t status)
{
    if (status != 0)
    {
        HAL_GPIO_WritePin(LED_RT_GPIO_Port, LED_RT_Pin, GPIO_PIN_RESET);
    }
    else
    {
        HAL_GPIO_WritePin(LED_RT_GPIO_Port, LED_RT_Pin, GPIO_PIN_SET);
    }
}

void ledGR(uint8_t status)
{
    if (status != 0)
    {
        HAL_GPIO_WritePin(LED_GR_GPIO_Port, LED_GR_Pin, GPIO_PIN_RESET);
    }
    else
    {
        HAL_GPIO_WritePin(LED_GR_GPIO_Port, LED_GR_Pin, GPIO_PIN_SET);
    }
}

//********************************************************************************
void Piep(uint16_t hoehe, uint16_t dauer)
{
    /*
    for(uint16_t i = 0; i < 10*(dauer/hoehe); i++)
	{
		SetBit(PORTD,PIEZO);
		_delay_us(5*hoehe);
		ClrBit(PORTD,PIEZO);
		_delay_us(5*hoehe);
	}
    */
}

//********************************************************************************
void SendCommand(uint8_t command)
{
    unsigned char i;
    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
    //rd=1;
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    for (i = 0; i < 8; i++)
    {
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        if ((command & 0x80) == 0)
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        }
        else
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        }
        command = command << 1;
        delay();
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        delay();
    }

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();
    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
}

//********************************************************************************
void SendData(uint8_t address, uint8_t write_data)
{
    unsigned char i;
    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
    //rd=1;
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_RESET);

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
    delay();
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    delay();

    address = address << 2;
    for (i = 0; i < 6; i++)
    {
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        if ((address & 0x80) == 0)
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        }
        else
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        }
        address = address << 1;
        delay();
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        delay();
    }

    for (i = 0; i < 4; i++)
    {
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        if ((write_data & 0x01) == 0x00)
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        }
        else
        {
            HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        }
        write_data = write_data >> 1;
        delay();
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        delay();
    }
    delay();
    HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
}

//********************************************************************************
void Clear(void)
{
    uint8_t i;

    for (i = 0; i <= 25; i++)
        SendData(i, 0);
}

//********************************************************************************

void Full(void)
{
    uint8_t i;

    for (i = 0; i <= 25; i++)
        SendData(i, 0xff);
}

//********************************************************************************
void Bild1(void)
{
    SendData(0, 7);
    SendData(1, 13);

    SendData(2, 7);
    SendData(3, 13);

    SendData(4, 7);
    SendData(5, 13);

    SendData(6, 7);
    SendData(7, 13);

    SendData(8, 11);
    SendData(9, 15);

    SendData(10, 7);
    SendData(11, 13);

    SendData(12, 7);
    SendData(13, 13);

    SendData(14, 7);
    SendData(15, 13);

    SendData(16, 7);
    SendData(17, 13);

    //Symbole
    SendData(18, 0);
    SendData(19, 0);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);

    SendData(24, 0);
}

//********************************************************************************
void Bild2(void)
{

    SendData(0, 14);
    SendData(1, 0);

    SendData(2, 6);
    SendData(3, 0);

    SendData(4, 6);
    SendData(5, 0);

    SendData(6, 14);
    SendData(7, 0);

    SendData(8, 10);
    SendData(9, 0);

    SendData(10, 6);
    SendData(11, 0);

    SendData(12, 14);
    SendData(13, 0);

    SendData(14, 6);
    SendData(15, 0);

    SendData(16, 6);
    SendData(17, 0);

    //Symbole
    SendData(18, 0);
    SendData(19, 0);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);
    SendData(24, 0);
}

//********************************************************************************

void Bild3(void)
{
    SendData(0, 3);
    SendData(1, 14);

    SendData(2, 3);
    SendData(3, 14);

    SendData(4, 3);
    SendData(5, 14);

    SendData(6, 3);
    SendData(7, 14);

    SendData(8, 7);
    SendData(9, 12);

    SendData(10, 3);
    SendData(11, 14);

    SendData(12, 11);
    SendData(13, 14);

    SendData(14, 3);
    SendData(15, 14);

    SendData(16, 3);
    SendData(17, 14);

    //Symbole
    SendData(18, 0);
    SendData(19, 0);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);
    SendData(24, 0);
}
//********************************************************************************

void Bild4(void)
{
    SendData(0, 5 + 8);
    SendData(1, 11);

    SendData(2, 5);
    SendData(3, 11);

    SendData(4, 5);
    SendData(5, 11);

    SendData(6, 5 + 8);
    SendData(7, 11);

    SendData(8, 13);
    SendData(9, 9);

    SendData(10, 5);
    SendData(11, 11);

    SendData(12, 5);
    SendData(13, 11);

    SendData(14, 5);
    SendData(15, 11);

    SendData(16, 5);
    SendData(17, 11);

    //Symbole
    //   SendData(2,0);
    //   SendData(10,0);
    SendData(18, 0);
    SendData(19, 0);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);
    SendData(24, 0);
}

//********************************************************************************

void Bild5(void)
{
    SendData(0, 0);
    SendData(1, 0);

    SendData(2, 0);
    SendData(3, 0);

    SendData(4, 0);
    SendData(5, 0);

    SendData(6, 0);
    SendData(7, 0);

    SendData(8, 0);
    SendData(9, 0);

    SendData(10, 0);
    SendData(11, 0);

    SendData(12, 0);
    SendData(13, 0);

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0);
    SendData(17, 0);

    //Symbole
    SendData(2, 8);
    SendData(10, 8);
    SendData(14, 8);
    SendData(16, 8);
    SendData(18, 1);
    SendData(19, 1);
    SendData(20, 1);
    SendData(21, 1);
    SendData(22, 0);
    SendData(23, 2);
    SendData(24, 1);
}

//********************************************************************************

void Bild6(void)
{
    SendData(0, 0);
    SendData(1, 0);

    SendData(2, 0);
    SendData(3, 0);

    SendData(4, 0);
    SendData(5, 0);

    SendData(6, 0);
    SendData(7, 0);

    SendData(8, 0);
    SendData(9, 0);

    SendData(10, 0);
    SendData(11, 0);

    SendData(12, 0);
    SendData(13, 0);

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0);
    SendData(17, 0);

    //Symbole
    SendData(2, 8);
    SendData(10, 8);
    SendData(14, 8);
    SendData(16, 8);
    SendData(18, 1);
    SendData(19, 1 + 8);
    SendData(20, 1 + 8);
    SendData(21, 1 + 2);
    SendData(22, 4);
    SendData(23, 2 + 1);
    SendData(24, 1 + 2);
}

//********************************************************************************

void Bild7(void)
{
    SendData(0, 0);
    SendData(1, 0);

    SendData(2, 0);
    SendData(3, 0);

    SendData(4, 0);
    SendData(5, 0);

    SendData(6, 0);
    SendData(7, 0);

    SendData(8, 0);
    SendData(9, 0);

    SendData(10, 0);
    SendData(11, 0);

    SendData(12, 0);
    SendData(13, 0);

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0);
    SendData(17, 0);

    //Symbole
    SendData(2, 8);
    SendData(10, 8);
    SendData(14, 8);
    SendData(16, 8);
    SendData(18, 1);
    SendData(19, 1 + 2);
    SendData(20, 1 + 2);
    SendData(21, 1 + 4);
    SendData(22, 2);
    SendData(23, 2 + 8);
    SendData(24, 1 + 4);
}

//********************************************************************************

void Bild8(void)
{
    SendData(0, 15);
    SendData(1, 15);

    SendData(2, 15);
    SendData(3, 15);

    SendData(4, 0);
    SendData(5, 0);

    SendData(6, 0);
    SendData(7, 0);

    SendData(8, 0);
    SendData(9, 0);

    SendData(10, 0);
    SendData(11, 0);

    SendData(12, 0);
    SendData(13, 0);

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0);
    SendData(17, 0);

    //Symbole
    //   SendData(2,8);
    SendData(10, 8);
    SendData(14, 8);
    SendData(16, 8);
    SendData(18, 1);
    SendData(19, 1 + 4);
    SendData(20, 1 + 4);
    SendData(21, 1 + 8);
    SendData(22, 2 + 4);
    SendData(23, 2 + 4 + 1);
    SendData(24, 1 + 8);
}

void Bild9(void)
{
    SendData(0, 0);
    SendData(1, 0);

    SendData(2, 0x01 + 0x02);
    SendData(3, 0);

    SendData(4, 0);
    SendData(5, 0x04); // li ob

    SendData(6, 0x04); // li ob
    SendData(7, 0);

    SendData(8, 0x00);
    SendData(9, 0x02);

    SendData(10, 0xff); //leer
    SendData(11, 0x00);

    SendData(12, 0x00);
    SendData(13, 0x02); // re un

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0);
    SendData(17, 0);

    //Symbole
    //   SendData(2,8);
    SendData(10, 0);
    SendData(14, 0);
    SendData(16, 0);
    SendData(18, 0);
    SendData(19, 0);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);
    SendData(24, 0);
}

void LCD_Marker(void)
{
    SendData(0, 255);
    SendData(1, 255);

    SendData(2, 0);
    SendData(3, 0);

    SendData(4, 0);
    SendData(5, 0);

    SendData(6, 0);
    SendData(7, 0);

    SendData(8, 0x02 + 0x08);
    SendData(9, 0);

    SendData(10, 3);
    SendData(11, 0);

    SendData(12, 0);
    SendData(13, 0);

    SendData(14, 0);
    SendData(15, 0);

    SendData(16, 0x01);
    SendData(17, 0x01);

    //Symbole
    //   SendData(2,8);

    SendData(18, 0);
    SendData(19, 0x02 + 0x04);
    SendData(20, 0);
    SendData(21, 0);
    SendData(22, 0);
    SendData(23, 0);
    SendData(24, 0);
}

void VisionBild1(void)
{
    for (uint8_t i = 0; i <= 24; i += 3)
    {
        SendData(i + 0, 0x49);
        SendData(i + 1, 0x92);
        SendData(i + 2, 0x24);
    }
}

void VisionBild2(void)
{
    for (uint8_t i = 0; i <= 24; i += 3)
    {
        SendData(i + 0, 0x92);
        SendData(i + 1, 0x24);
        SendData(i + 2, 0x49);
    }
}

void VisionBild3(void)
{
    for (uint8_t i = 0; i <= 24; i += 3)
    {
        SendData(i + 0, 0x24);
        SendData(i + 1, 0x49);
        SendData(i + 2, 0x24);
    }
}

//********************************************************************************

void Init(void)
{
    //SetBit(PORTD, WR);         // /WR = HI
    HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
    //SetBit(PORTD, RD);         // /RD = HI
    HAL_GPIO_WritePin(DISP_RD_GPIO_Port, DISP_RD_Pin, GPIO_PIN_SET);
    SendCommand(1);            // Turn on system oszillator
                               // SendCommand(0x14);	           // Ext. Quarz
    SendCommand(0x18);         // int. oszillator
    SendCommand(3);            // Turn on BIAS generator
    SendCommand(0x20 + 8 + 1); // 1/3 Bias 1:4 Multiplex
}

//********************************************************************************
// Zeug fuer Encoder
//********************************************************************************
//#define PHASE_A (PINB & _BV(ENC_A)) // Encoder an PortB,0
//#define PHASE_B (PINB & _BV(ENC_B)) // Encoder an PortB,1

//volatile int8_t enc_delta; // -128 ... 127
//static int8_t last;

void encode_init(void)
{
    /*
        int8_t new;

        new = 0;
        if( PHASE_A )
        new = 3;
        if( PHASE_B )
        new ^= 1;					// convert gray to binary
        last = new;					// power on state
        enc_delta = 0;
        TCCR0 = _BV(CS01)|_BV(CS00);		// CTC, XTAL / 64
        //  OCR0 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);	// 1ms
        TIMSK |= _BV(TOIE0);
  */
}

uint8_t timer_counter;
/*
    void ISR(TIMER0_OVF_vect) // 1ms for manual movement
    {
    
        int8_t new, diff;

        new = 0;
        if( PHASE_A )
        new = 3;
        if( PHASE_B )
        new ^= 1;					// convert gray to binary
        diff = last - new;				// difference last - new
        if( diff & 1 ){				// bit 0 = value (1)
        last = new;					// store new as next last
        enc_delta += (diff & 2) - 1;		// bit 1 = direction (+/-)
        }

        timer_counter++;
        if (timer_counter > 100) {
        timer_counter = 0;
        PORTC = PORTC ^ 0b00100000;		// Lebenszeichen
        }
  
}
*/

int8_t encode_read2(void) // read two step encoders
{
    /*
        int8_t val;

        cli();
        val = enc_delta;
        enc_delta = val & 1;
        sei();
        return val >> 1;
  */
    // only rm warning
    //return last;

    int8_t val = 0;
    if(secondRotate != 0) {
      if( (secondRotate - firstRotate) == (BUT_LEFT_Pin - BUT_RIGHT_Pin) )
      {
        //printf("left\r\n");
        val = 1;
      }
      else
      {
        //printf("right\r\n");
        val = -1;
      }
      firstRotate = 0;
      secondRotate = 0;
      changePinMode(firstRotate, GPIO_MODE_IT_RISING_FALLING);
    }

    return val;
}

//********************************************************************************
// RS232 Zeug
//********************************************************************************
/*#ifndef F_CPU
  #warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 800000"
  #define F_CPU 800000UL    // Systemtakt in Hz
#endif
 
#define BAUD 9600UL          // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate gr�sser 1% und damit zu hoch! 
#endif
*/

void serial_init(void)
{
    /*
    UCSRB |= _BV(TXEN)|_BV(RXEN);            	// UART TX & RX einschalten
    UCSRC |= _BV(URSEL)|_BV(UCSZ0)|_BV(UCSZ1);	// Asynchron 8N1 
 
    UBRRH = UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    */
}

void send_byte(uint8_t value)
{
    /*
    while (!(UCSRA & (1<<UDRE)))  // warten bis Senden moeglich                   
    {
    }
 
    UDR = value;                    // schreibt das Zeichen x auf die Schnittstelle 
    */
   
   HAL_UART_Transmit_IT(&huart1, &value, 1);
}

/*
void send_zahl(uint16_t v) {
	send_byte(0x30+(v % 10000)/1000);
	send_byte(0x30+(v %  1000)/100);
	send_byte(0x30+(v %   100)/10);
	send_byte(0x30+(v %    10)/1);
	send_byte(0x0A);

	
}
*/

uint8_t value = 0;

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
    //HAL_UART_Transmit(&huart1, (uint8_t *)&"\r\ninto HAL_UART_RxCpltCallback\r\n",32,0xffff);    //验证进入这个函数了
    //HAL_UART_Transmit(&huart1,(uint8_t *)&value,1,0xffff); //把接收到的数据通过串口发送出去        
    HAL_UART_Receive_IT(&huart1,(uint8_t *)&value,1); //重新打开串口中断
}

uint8_t read_byte(void)
{
    /*
   // Warten bis Daten empfangen wurden 等待数据被接收
   if (UCSRA & (1<<RXC)) 
   {
      return UDR;
   } else {
      return 0;
   }
   */

    uint8_t temp = value;
    value = 0;
    return temp;
}

//********************************************************************************

int8_t GetTaster(void)
{
    // Return:
    //     0: keine Taste / keine �nderung 没有钥匙/没有变化
    //     1: Taste grd�ckt 按钮长大

    /*
	uint8_t key = 0;
	static uint8_t oldkey;	
	
	key = (~PINB) & 0x04;				// Tastenstatus einlesen 读取按键状态

	if (oldkey == key) return 0;		// nichts ge�ndert seit letzem mal -> ende 自上次以来没有任何变化->结束
	oldkey = key;
	
	if ((key & 0x04) != 0) return 1;	// Taster gedr�ckt	按下按钮
	
	return 0;
    */
    uint8_t key = 0;
    static uint8_t oldKey;

    key = HAL_GPIO_ReadPin(BUT_Z_GPIO_Port, BUT_Z_Pin);

    if(oldKey == key)
    {
        return 0;
    }

    oldKey = key;

    if(key == GPIO_PIN_SET)
    {
        return 1;
    }

    return 0;
}
// MOD


uint16_t current;

void checkCurrent(void)
{
    /*
    ADCSR=(1<<ADEN)|(0<<ADPS0)|(1<<ADPS1)|(1<<ADPS2); // ADC eingeschaltet, 64 Bit Prescale
	ADMUX=(1<<REFS1)|(1<<REFS0)|0x06;
	
	current = 0;
	
	for (uint8_t i = 0; i < 4; i++) {
		ADCSR |= _BV(6);  // single conversion mode ein
		while((ADCSR & _BV(6)) !=0) ;  // warten bis konvertierung abgeschlosen
    	current += ADCW;
	}
	
	current = current / 16;
	//send_zahl(current);
    */
}

//********************************************************************************

#define PR_BEGIN 0
#define PR_P1_BUTTON PR_BEGIN + 5 // 4 x Taster
#define PR_P2_ENC_L PR_P1_BUTTON + 15
#define PR_P3_ENC_R PR_P2_ENC_L + 15
#define PR_P4_ENC_L PR_P3_ENC_R + 15
#define PR_P5_BUTTON PR_P4_ENC_L + 4

#define min_current 100     // 10mA
#define max_current 160     // 16mA
#define no_module_current 4 // 0,4mA

uint8_t pruefung = PR_BEGIN;

#define SERVOMAX 70

/*
    void setServo(uint16_t v)
    {
        PORTC |= _BV(1);
        _delay_us(1200);
        for (uint16_t i = 0; i <= v; i++) _delay_us(10);
        PORTC &= ~_BV(1);
    }
*/

void printStep(void)
{
    //printf("step: %d\r\n", pruefung);
}

void testC43020(void)
{
    uint8_t bild = 0;
    int8_t key;

    uint16_t key_delay = 0;

    /*
        DDRB = 0x00;      	// PortB Eingang
        PORTB = 0xf0;
        DDRC = 0xff;
        PORTC = 0xff;
        DDRD = 0xfe;		// PortD ist Ausgang (Bit0 = RX)
	*/

    Init();
    serial_init();

    HAL_UART_Receive_IT(&huart1, &value, 1);
    encode_init();
    //sei();

    Clear();
    Led(0);ledGR(0);ledRT(0);

    for (;;)
    {
        _delay_ms(10);

        // Stromverbrauch
    /*
        checkCurrent();

        if (current < no_module_current)
        {
            Led(0); // Alle LEDs aus, kein Modul da!所有指示灯熄灭，那里没有模块！
            pruefung = 0;
            BL_ON;
        }
        else if (pruefung == PR_BEGIN)
        {
            pruefung++;
            BL_ON;
        }
    */

        if(pruefung == PR_BEGIN)
        {
            int getKey = 0;
            while (getKey == 0)
            {
                getKey = GetTaster();
                
            }
            pruefung++;
            printStep();
            BL_ON;
            send_byte(0x30);
        }



    /*
		// Status LEDs
		if (pruefung == PR_BEGIN) 									    Led(0);		// Alle LED aus所有LED熄灭
		if ((pruefung > PR_BEGIN)      && (pruefung < PR_P1_BUTTON))	Led(LED1);		
		if ((pruefung >= PR_P1_BUTTON) && (pruefung < PR_P2_ENC_L))	Led(LED2);		
		if ((pruefung >= PR_P2_ENC_L)  && (pruefung < PR_P3_ENC_R))	Led(LED3);		
		if ((pruefung >= PR_P3_ENC_R)  && (pruefung < PR_P4_ENC_L))	Led(LED4);		
		if ((pruefung >= PR_P4_ENC_L)  && (pruefung < PR_P5_BUTTON))	Led(LED1 + LED2);		
		if ((pruefung >= PR_P5_BUTTON) && (pruefung < PR_P5_BUTTON+5))	Led(LED1 + LED3);	
    */	
        if (pruefung == PR_BEGIN) 									    {Led(0);ledGR(0);ledRT(0);}		// Alle LED aus所有LED熄灭
		if ((pruefung > PR_BEGIN)      && (pruefung < PR_P1_BUTTON))	{Led(0);ledGR(0);ledRT(1);}	
		if ((pruefung >= PR_P1_BUTTON) && (pruefung < PR_P2_ENC_L))	    {Led(0);ledGR(1);ledRT(0);}	
		if ((pruefung >= PR_P2_ENC_L)  && (pruefung < PR_P3_ENC_R))	    {Led(0);ledGR(1);ledRT(1);}
		if ((pruefung >= PR_P3_ENC_R)  && (pruefung < PR_P4_ENC_L))	    {Led(1);ledGR(0);ledRT(0);}	
		if ((pruefung >= PR_P4_ENC_L)  && (pruefung < PR_P5_BUTTON))	{Led(1);ledGR(0);ledRT(1);}		
		if ((pruefung >= PR_P5_BUTTON) && (pruefung < PR_P5_BUTTON+5))	{Led(1);ledGR(1);ledRT(0);}
		




        if (key_delay < 5000)
            key_delay++;

        if (GetTaster())
        {
            //Piep(50,100);
            BL_OFF;
            Init();
            Clear();
            bild = 0;
            BL_ON;
            /*if ((pruefung > PR_BEGIN) && (pruefung < PR_P1_BUTTON))
            {
            
                pruefung++;
                printStep();
            }
            if (pruefung == PR_P1_BUTTON)
            {
                Piep(300, 1000);
                pruefung++;
                printStep();
            }
            if ((pruefung >= PR_P4_ENC_L) && (pruefung < PR_P5_BUTTON))
            {
                pruefung++;
                printStep();
            }
            if ((pruefung == PR_P5_BUTTON))
            {
                Piep(400, 2000);
                Piep(200, 2000);
                Piep(100, 2000);
                pruefung = 0;
                //printStep();
                //send_byte(0x30);
            }*/

            send_byte(0x30);
        }

        key = read_byte();

        if (key == '1')
        {
            BL_ON;
            Init();
            VisionBild1();
        }

        if (key == '2')
        {
            BL_ON;
            Init();
            VisionBild2();
        }

        if (key == '3')
        {
            BL_ON;
            Init();
            VisionBild3();
        }

        if (key == '4') // Good
        {
            BL_ON;
            Init();
            LCD_Marker();
            for (uint8_t i = 0; i < 100; i++)
                Piep(350 - i * 3 - (i * 8) % 50, 150);
        }

        if (key == '8') // Good / Salmson
        {
            BL_ON;
            Init();
            Bild9();
            for (uint8_t i = 0; i < 100; i++)
                Piep(350 - i * 3 - (i * 8) % 50, 150);
        }

        if (key == '5') // Bad
        {
            BL_ON;
            Init();
            Bild2();
            for (uint8_t i = 0; i < 100; i++)
                Piep(100 + i * 8, 400);
        }

        key = encode_read2();

        if ((key == 1) || (key == -1))
        {
            /*
                key_delay = 0;
                
                if (key_delay < 2) {
                        pruefung = 0;
                        Piep(50,200);			
                        _delay_ms(100);
                        Piep(50,200);			
                        _delay_ms(100);
                        Piep(50,200);			
                }
			*/

            bild += key;

            //Piep(50,200);
            if ((pruefung > PR_P1_BUTTON) && (pruefung < PR_P2_ENC_L))
            {
                if (key == 1)
                    {pruefung++;
                    printStep();}
                if ((key == -1) && (pruefung > PR_P1_BUTTON + 1))
                {
                    pruefung = 0;
                    printStep();
                    Piep(1000, 2000);
                }
                if (pruefung == PR_P2_ENC_L)
                    Piep(400, 1000);
                if (key_delay < 2)
                {
                    pruefung = 0;
                    printStep();
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                }
            }
            if ((pruefung >= PR_P2_ENC_L) && (pruefung < PR_P3_ENC_R))
            {
                if (key == -1)
                    {pruefung++;
                    printStep();}
                if ((key == 1) && (pruefung > PR_P2_ENC_L))
                {
                    pruefung = 0;
                    printStep();
                    Piep(1000, 2000);
                }
                if (pruefung == PR_P3_ENC_R)
                    Piep(400, 1000);
                if ((key_delay < 2) && (pruefung > PR_P2_ENC_L))
                {
                    pruefung = 0;
                    printStep();
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                }
            }
            if ((pruefung >= PR_P3_ENC_R) && (pruefung < PR_P4_ENC_L))
            {
                if (key == 1)
                    {pruefung++;
                    printStep();}
                if ((key == -1) && (pruefung > PR_P3_ENC_R))
                {
                    pruefung = 0;
                    printStep();
                    Piep(1000, 2000);
                }
                if (pruefung == PR_P4_ENC_L)
                    Piep(400, 5000);
                if ((key_delay < 2) && (pruefung > PR_P3_ENC_R))
                {
                    pruefung = 0;
                    printStep();
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                    _delay_ms(100);
                    Piep(50, 200);
                }
            }

            if (bild > 14)
                bild = 1;
            if (bild < 1)
                bild = 14;

            //send_byte(bild+'0');

            switch (bild)
            {
            case 1:
            {
                Bild1();
                break;
            }
            case 2:
            {
                Bild2();
                break;
            }
            case 3:
            {
                Bild3();
                break;
            }
            case 4:
            {
                Bild4();
                break;
            }
            case 5:
            {
                Bild5();
                break;
            }
            case 6:
            {
                Bild6();
                break;
            }
            case 7:
            {
                Bild7();
                break;
            }
            case 8:
            {
                Bild8();
                break;
            }
            case 9:
            {
                Bild9();
                break;
            }
            case 10:
            {
                VisionBild1();
                break;
            }
            case 11:
            {
                VisionBild2();
                break;
            }
            case 12:
            {
                VisionBild3();
                break;
            }
            case 13:
            {
                Full();
                break;
            }
            case 14:
            {
                LCD_Marker();
                break;
            }
            }

            key_delay = 0;
        }
    }

    return;
}



#ifdef DEBUG
void TEST_led_gr_rt(void)
{
    while (1)
    {
        ledRT(1);
        HAL_Delay(50);
        ledRT(0);
        HAL_Delay(50);

        ledRT(1);
        HAL_Delay(50);
        ledRT(0);
        HAL_Delay(50);

        ledGR(1);
        HAL_Delay(50);
        ledGR(0);
        HAL_Delay(50);

        ledGR(1);
        HAL_Delay(50);
        ledGR(0);
        HAL_Delay(50);

        ledGR(1);
        HAL_Delay(50);
        ledGR(0);
        HAL_Delay(50);

        ledRT(0);
        ledGR(0);
        HAL_Delay(2000);
    }
}

void TEST_userLedFlash(void)
{
    while (1)
    {
        userLedFlash(5, 50, 50);

        HAL_Delay(1000);
    }
}

void TEST_bl(void)
{
    while (1)
    {
        BL_OFF;
        HAL_Delay(100);
        BL_ON;
        HAL_Delay(100);

        BL_OFF;
        HAL_Delay(100);
        BL_ON;
        HAL_Delay(100);

        BL_OFF;
        HAL_Delay(100);
        BL_ON;
        HAL_Delay(100);

        BL_OFF;
        HAL_Delay(100);
        BL_ON;
        HAL_Delay(100);

        BL_OFF;
        HAL_Delay(2000);
    }
}

void TEST_lcd_io(void)
{

    while (1)
    {

        //--------------------
        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        Clock();

        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        Clock();

        //--------------------
        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        Clock();

        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        Clock();

        //--------------------
        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_RESET);
        Clock();

        HAL_GPIO_WritePin(DISP_CS_GPIO_Port, DISP_CS_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_DATA_GPIO_Port, DISP_DATA_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(DISP_WR_GPIO_Port, DISP_WR_Pin, GPIO_PIN_SET);
        Clock();

        userLedFlash(3, 10, 10);
    }
}

void TEST_lcd(void)
{
    BL_ON;
    HAL_Delay(100);

    Init();
    while (1)
    {
        ledRT(1);
        HAL_Delay(50);
        ledRT(0);
        HAL_Delay(50);

        ledRT(1);
        HAL_Delay(50);
        ledRT(0);
        HAL_Delay(50);

        Full();
        HAL_Delay(1000);

        Clear();
        HAL_Delay(1000);

        VisionBild1();
        HAL_Delay(1000);

        VisionBild2();
        HAL_Delay(1000);

        VisionBild3();
        HAL_Delay(1000);

        Bild1();
        HAL_Delay(400);

        Bild2();
        HAL_Delay(400);

        Bild3();
        HAL_Delay(400);

        Bild4();
        HAL_Delay(400);

        Bild5();
        HAL_Delay(400);

        Bild6();
        HAL_Delay(400);

        Bild7();
        HAL_Delay(400);

        Bild8();
        HAL_Delay(400);

        Bild9();
        HAL_Delay(400);
    }
}

void TEST_Uart(void)
{
    uint8_t rxdata = 0;

    ledRT(0);
    ledGR(0);

    HAL_UART_StateTypeDef uartState = 0;
    while(uartState != HAL_UART_STATE_READY)
    {
        uartState = HAL_UART_GetState(&huart1);
        HAL_Delay(1);
    }

    HAL_UART_Receive_IT(&huart1, &value, 1);
    
    while (1)
    {
        rxdata = read_byte();

        if (rxdata)
        {

            switch (rxdata)
            {
            case 0x30:
                HAL_GPIO_TogglePin(LED_RT_GPIO_Port, LED_RT_Pin);
                break;
            case 0x31:
                HAL_GPIO_TogglePin(LED_GR_GPIO_Port, LED_GR_Pin);
                break;
            case 0x32:
                HAL_GPIO_TogglePin(LED_GR_GPIO_Port, LED_GR_Pin);
                HAL_GPIO_TogglePin(LED_RT_GPIO_Port, LED_RT_Pin);
                break;

            default:
                break;
            }
        }

        rxdata = 0;

    }
}

#endif